package cn.biplam.common.wrapper.tree;

import java.util.ArrayList;

import cn.biplam.common.tools.TOOLS;

/**
 * 链表节点数据结构类
 * @author XiaoRuxing 2009-5-19下午08:57:25
 * @version 1.0
 */
public class LinkListNode<Node> {

	/** 当前节点内容 */
	protected Node data;
	/** 前序节点 */
	protected LinkListNode<Node> preNodes;
	/** 后序节点 */
	protected ArrayList<LinkListNode<Node>> nextNodes;

	/**
	 * 创建一个链表节点
	 * @param data     节点内容
	 * @param nextNode 后序节点
	 */
	public LinkListNode(Node data){
		this.data=data;
		this.nextNodes=new ArrayList<LinkListNode<Node>>();
	}


	/**
	 * 获取节点内容
	 * @return 节点内容
	 */
	public Node getData() {
		return data;
	}
	
	/**
	 * 获取节点是否为空
	 * @return 节点内容为空时返回true否则返回false
	 */
	public boolean isNull(){
		return this.data==null;
	}
	
	/**
	 * 设置节点内容
	 * @param data 节点内容
	 */
	public void setData(Node data) {
		this.data = data;
	}


	/**
	 * 获取当前节点所有后续节点
	 * @return
	 */
	public ArrayList<LinkListNode<Node>> getNextNodes() {
		return nextNodes;
	}


	/**
	 * 增加当前节点的一个后续节点
	 * @param nextNode 后续节点
	 */
	public void addNextNode(LinkListNode<Node> nextNode) {
		String tn=((TreeNode)nextNode.getData()).getSequence();
		int nodeSqeuence=-1;
		if(tn!=null&&!"".equals(tn)){
			nodeSqeuence=_getNodeOrder(tn);
			this.nextNodes.add(nodeSqeuence, nextNode);
		}else{
			this.nextNodes.add(nextNode);
		}
	}

	/**
	 * 计算节点在当前兄弟节点中的排序  
	 */
	private int _getNodeOrder(String sequence){
		ArrayList<LinkListNode<Node>> childs=this.getNextNodes();
		int currentSequence=TOOLS.stringToInt(sequence);
		int brotherSequence=0;
		int order=0;
		for(int i=childs.size()-1;i>=0;i--){
			LinkListNode<Node> node=childs.get(i);
			TreeNode tNode=null;
			if(node.getData() instanceof TreeNode){//如果节点数据类型不是树数据类型将当前节点插入队尾
				tNode=(TreeNode)node.getData();
			}else{
				return i;
			}
			String tNodeSequence=tNode.getSequence();
			if(tNodeSequence!=null){//如果兄弟节点的序号为空则认为兄弟节点的序号为当前在兄弟中的位置
				brotherSequence=TOOLS.stringToInt(tNodeSequence);
			}else{
				brotherSequence=i;
			}
			if(currentSequence>brotherSequence){//如果找到当前节点的序号小的兄弟节点，将当前节点放在找到的节点后
				return i+1;
			}
		}
		return order;
	}

	/**
	 * 获取当前节点的所有前序节点
	 * @return 返回当前节点所有前序节点
	 */
	public LinkListNode<Node> getPreNodes() {
		return preNodes;
	}

	/**
	 * 添加当前节点的一个前序节点
	 * @param preNode 前序节点
	 */
	public void addPreNode(LinkListNode<Node> preNode) {
		this.preNodes = preNode;
	}
	
	/**
	 * 是否有儿子 
	 * @return 节点是否有儿子
	 */
	public boolean haveChild(){
		if(this.nextNodes.size()>0){
			return true;
		}else{
			return false;
		}
	}
	
	/**
	 * 获取当前链表节点是否和指定链表节点相等
	 * @param compareNode 比较节点
	 * @return 当前链表节点是否和指定链表节点相等
	 */
	public boolean equals(LinkListNode<Node> compareNode){
		return this.data.equals(compareNode.getData());
	}
}
